/*
 *    Copyright 2009-2013 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.apache.ibatis.binding;

import org.apache.ibatis.annotations.MapKey;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.SqlCommandType;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.session.SqlSession;

import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.util.*;

/**
 * @author Clinton Begin
 * @author Eduardo Macarron
 * @author Lasse Voss
 */
public class MapperMethod {

	private final SqlCommand command;
	private final MethodSignature method;

	public MapperMethod(
			Class<?> mapperInterface,
			Method method,
			Configuration config) {
		this.command = new SqlCommand(
				config,
				mapperInterface, method);
		this.method = new MethodSignature(
				config, method);
	}

	public Object execute(
			SqlSession sqlSession,
			Object[] args) {
		Object result;
		if (SqlCommandType.INSERT == command
				.getType()) {
			Object param = method
					.convertArgsToSqlCommandParam(args);
			result = rowCountResult(sqlSession
					.insert(command
							.getName(),
							param));
		} else if (SqlCommandType.UPDATE == command
				.getType()) {
			Object param = method
					.convertArgsToSqlCommandParam(args);
			result = rowCountResult(sqlSession
					.update(command
							.getName(),
							param));
		} else if (SqlCommandType.DELETE == command
				.getType()) {
			Object param = method
					.convertArgsToSqlCommandParam(args);
			result = rowCountResult(sqlSession
					.delete(command
							.getName(),
							param));
		} else if (SqlCommandType.SELECT == command
				.getType()) {
			if (method.returnsVoid()
					&& method
							.hasResultHandler()) {
				executeWithResultHandler(
						sqlSession,
						args);
				result = null;
			} else if (method
					.returnsMany()) {
				result = executeForMany(
						sqlSession,
						args);
			} else if (method
					.returnsMap()) {
				result = executeForMap(
						sqlSession,
						args);
			} else {
				Object param = method
						.convertArgsToSqlCommandParam(args);
				result = sqlSession
						.selectOne(
								command.getName(),
								param);
			}
		} else {
			throw new BindingException(
					"Unknown execution method for: "
							+ command
									.getName());
		}
		if (result == null
				&& method
						.getReturnType()
						.isPrimitive()
				&& !method
						.returnsVoid()) {
			throw new BindingException(
					"Mapper method '"
							+ command
									.getName()
							+ " attempted to return null from a method with a primitive return type ("
							+ method.getReturnType()
							+ ").");
		}
		return result;
	}

	private Object rowCountResult(
			int rowCount) {
		final Object result;
		if (method.returnsVoid()) {
			result = null;
		} else if (Integer.class
				.equals(method
						.getReturnType())
				|| Integer.TYPE
						.equals(method
								.getReturnType())) {
			result = rowCount;
		} else if (Long.class
				.equals(method
						.getReturnType())
				|| Long.TYPE
						.equals(method
								.getReturnType())) {
			result = (long) rowCount;
		} else if (Boolean.class
				.equals(method
						.getReturnType())
				|| Boolean.TYPE
						.equals(method
								.getReturnType())) {
			result = (rowCount > 0);
		} else {
			throw new BindingException(
					"Mapper method '"
							+ command
									.getName()
							+ "' has an unsupported return type: "
							+ method.getReturnType());
		}
		return result;
	}

	private void executeWithResultHandler(
			SqlSession sqlSession,
			Object[] args) {
		MappedStatement ms = sqlSession
				.getConfiguration()
				.getMappedStatement(
						command.getName());
		if (void.class.equals(ms
				.getResultMaps().get(0)
				.getType())) {
			throw new BindingException(
					"method "
							+ command
									.getName()
							+ " needs either a @ResultMap annotation, a @ResultType annotation,"
							+ " or a resultType attribute in XML so a ResultHandler can be used as a parameter.");
		}
		Object param = method
				.convertArgsToSqlCommandParam(args);
		if (method.hasRowBounds()) {
			RowBounds rowBounds = method
					.extractRowBounds(args);
			sqlSession
					.select(command
							.getName(),
							param,
							rowBounds,
							method.extractResultHandler(args));
		} else {
			sqlSession
					.select(command
							.getName(),
							param,
							method.extractResultHandler(args));
		}
	}

	private <E> Object executeForMany(
			SqlSession sqlSession,
			Object[] args) {
		List<E> result;
		Object param = method
				.convertArgsToSqlCommandParam(args);
		if (method.hasRowBounds()) {
			RowBounds rowBounds = method
					.extractRowBounds(args);
			result = sqlSession
					.<E> selectList(
							command.getName(),
							param,
							rowBounds);
		} else {
			result = sqlSession
					.<E> selectList(
							command.getName(),
							param);
		}
		// issue #510 Collections & arrays support
		if (!method
				.getReturnType()
				.isAssignableFrom(
						result.getClass())) {
			if (method.getReturnType()
					.isArray()) {
				return convertToArray(result);
			} else {
				return convertToDeclaredCollection(
						sqlSession
								.getConfiguration(),
						result);
			}
		}
		return result;
	}

	private <E> Object convertToDeclaredCollection(
			Configuration config,
			List<E> list) {
		Object collection = config
				.getObjectFactory()
				.create(method
						.getReturnType());
		MetaObject metaObject = config
				.newMetaObject(collection);
		metaObject.addAll(list);
		return collection;
	}

	@SuppressWarnings("unchecked")
	private <E> E[] convertToArray(
			List<E> list) {
		E[] array = (E[]) Array
				.newInstance(
						method.getReturnType()
								.getComponentType(),
						list.size());
		array = list.toArray(array);
		return array;
	}

	private <K, V> Map<K, V> executeForMap(
			SqlSession sqlSession,
			Object[] args) {
		Map<K, V> result;
		Object param = method
				.convertArgsToSqlCommandParam(args);
		if (method.hasRowBounds()) {
			RowBounds rowBounds = method
					.extractRowBounds(args);
			result = sqlSession
					.<K, V> selectMap(
							command.getName(),
							param,
							method.getMapKey(),
							rowBounds);
		} else {
			result = sqlSession
					.<K, V> selectMap(
							command.getName(),
							param,
							method.getMapKey());
		}
		return result;
	}

	public static class ParamMap<V>
			extends HashMap<String, V> {

		private static final long serialVersionUID = -2212268410512043556L;

		@Override
		public V get(Object key) {
			if (!super.containsKey(key)) {
				throw new BindingException(
						"Parameter '"
								+ key
								+ "' not found. Available parameters are "
								+ keySet());
			}
			return super.get(key);
		}

	}

	public static class SqlCommand {

		private final String name;
		private final SqlCommandType type;

		public SqlCommand(
				Configuration configuration,
				Class<?> mapperInterface,
				Method method)
				throws BindingException {
			String statementName = mapperInterface
					.getName()
					+ "."
					+ method.getName();
			MappedStatement ms = null;
			if (configuration
					.hasStatement(statementName)) {
				ms = configuration
						.getMappedStatement(statementName);
			} else if (!mapperInterface
					.equals(method
							.getDeclaringClass()
							.getName())) { // issue #35
				String parentStatementName = method
						.getDeclaringClass()
						.getName()
						+ "."
						+ method.getName();
				if (configuration
						.hasStatement(parentStatementName)) {
					ms = configuration
							.getMappedStatement(parentStatementName);
				}
			}
			if (ms == null) {
				throw new BindingException(
						"Invalid bound statement (not found): "
								+ statementName);
			}
			name = ms.getId();
			type = ms
					.getSqlCommandType();
			if (type == SqlCommandType.UNKNOWN) {
				throw new BindingException(
						"Unknown execution method for: "
								+ name);
			}
		}

		public String getName() {
			return name;
		}

		public SqlCommandType getType() {
			return type;
		}
	}

	public static class MethodSignature {

		private final boolean returnsMany;
		private final boolean returnsMap;
		private final boolean returnsVoid;
		private final Class<?> returnType;
		private final String mapKey;
		private final Integer resultHandlerIndex;
		private final Integer rowBoundsIndex;
		private final SortedMap<Integer, String> params;
		private final boolean hasNamedParameters;

		public MethodSignature(
				Configuration configuration,
				Method method)
				throws BindingException {
			this.returnType = method
					.getReturnType();
			this.returnsVoid = void.class
					.equals(this.returnType);
			this.returnsMany = (configuration
					.getObjectFactory()
					.isCollection(
							this.returnType) || this.returnType
					.isArray());
			this.mapKey = getMapKey(method);
			this.returnsMap = (this.mapKey != null);
			this.hasNamedParameters = hasNamedParams(method);
			this.rowBoundsIndex = getUniqueParamIndex(
					method,
					RowBounds.class);
			this.resultHandlerIndex = getUniqueParamIndex(
					method,
					ResultHandler.class);
			this.params = Collections
					.unmodifiableSortedMap(getParams(
							method,
							this.hasNamedParameters));
		}

		public Object convertArgsToSqlCommandParam(
				Object[] args) {
			final int paramCount = params
					.size();
			if (args == null
					|| paramCount == 0) {
				return null;
			} else if (!hasNamedParameters
					&& paramCount == 1) {
				return args[params
						.keySet()
						.iterator()
						.next()];
			} else {
				final Map<String, Object> param = new ParamMap<Object>();
				int i = 0;
				for (Map.Entry<Integer, String> entry : params
						.entrySet()) {
					param.put(
							entry.getValue(),
							args[entry
									.getKey()]);
					// issue #71, add param names as param1, param2...but ensure
					// backward compatibility
					final String genericParamName = "param"
							+ String.valueOf(i + 1);
					if (!param
							.containsKey(genericParamName)) {
						param.put(
								genericParamName,
								args[entry
										.getKey()]);
					}
					i++;
				}
				return param;
			}
		}

		public boolean hasRowBounds() {
			return (rowBoundsIndex != null);
		}

		public RowBounds extractRowBounds(
				Object[] args) {
			return (hasRowBounds() ? (RowBounds) args[rowBoundsIndex]
					: null);
		}

		public boolean hasResultHandler() {
			return (resultHandlerIndex != null);
		}

		public ResultHandler extractResultHandler(
				Object[] args) {
			return (hasResultHandler() ? (ResultHandler) args[resultHandlerIndex]
					: null);
		}

		public String getMapKey() {
			return mapKey;
		}

		public Class<?> getReturnType() {
			return returnType;
		}

		public boolean returnsMany() {
			return returnsMany;
		}

		public boolean returnsMap() {
			return returnsMap;
		}

		public boolean returnsVoid() {
			return returnsVoid;
		}

		private Integer getUniqueParamIndex(
				Method method,
				Class<?> paramType) {
			Integer index = null;
			final Class<?>[] argTypes = method
					.getParameterTypes();
			for (int i = 0; i < argTypes.length; i++) {
				if (paramType
						.isAssignableFrom(argTypes[i])) {
					if (index == null) {
						index = i;
					} else {
						throw new BindingException(
								method.getName()
										+ " cannot have multiple "
										+ paramType
												.getSimpleName()
										+ " parameters");
					}
				}
			}
			return index;
		}

		private String getMapKey(
				Method method) {
			String mapKey = null;
			if (Map.class
					.isAssignableFrom(method
							.getReturnType())) {
				final MapKey mapKeyAnnotation = method
						.getAnnotation(MapKey.class);
				if (mapKeyAnnotation != null) {
					mapKey = mapKeyAnnotation
							.value();
				}
			}
			return mapKey;
		}

		private SortedMap<Integer, String> getParams(
				Method method,
				boolean hasNamedParameters) {
			final SortedMap<Integer, String> params = new TreeMap<Integer, String>();
			final Class<?>[] argTypes = method
					.getParameterTypes();
			for (int i = 0; i < argTypes.length; i++) {
				if (!RowBounds.class
						.isAssignableFrom(argTypes[i])
						&& !ResultHandler.class
								.isAssignableFrom(argTypes[i])) {
					String paramName = String
							.valueOf(params
									.size());
					if (hasNamedParameters) {
						paramName = getParamNameFromAnnotation(
								method,
								i,
								paramName);
					}
					params.put(i,
							paramName);
				}
			}
			return params;
		}

		private String getParamNameFromAnnotation(
				Method method, int i,
				String paramName) {
			final Object[] paramAnnos = method
					.getParameterAnnotations()[i];
			for (Object paramAnno : paramAnnos) {
				if (paramAnno instanceof Param) {
					paramName = ((Param) paramAnno)
							.value();
				}
			}
			return paramName;
		}

		private boolean hasNamedParams(
				Method method) {
			boolean hasNamedParams = false;
			final Object[][] paramAnnos = method
					.getParameterAnnotations();
			for (Object[] paramAnno : paramAnnos) {
				for (Object aParamAnno : paramAnno) {
					if (aParamAnno instanceof Param) {
						hasNamedParams = true;
						break;
					}
				}
			}
			return hasNamedParams;
		}

	}

}
